home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / include / sun3.md / RCS / math-68881.h,v < prev    next >
Encoding:
Text File  |  1990-09-11  |  9.5 KB  |  441 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     90.09.11.14.50.17;  author kupfer;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     90.09.07.17.34.31;  author kupfer;  state Exp;
  16. branches ;
  17. next     ;
  18.  
  19.  
  20. desc
  21. @Inline version of some math routines, using the 68881 coprocessor.
  22. @
  23.  
  24.  
  25. 1.2
  26. log
  27. @Second argument to modf points to a double, not an int.
  28. @
  29. text
  30. @
  31. /*******************************************************************
  32. *                                                                  *
  33. *  <math-68881.h>               last modified: March 22, 1989.     *
  34. *                                                                  *
  35. *  Copyright (C) 1989 by Matthew Self.                             *
  36. *  You may freely distribute verbatim copies of this software      *
  37. *  provided that this copyright notice is retained in all copies.  *
  38. *  You may distribute modifications to this software under the     *
  39. *  conditions above if you also clearly note such modifications    *
  40. *  with their author and date.                                     *
  41. *                                                                  *
  42. *  Note:  errno is not set to EDOM when domain errors occur for    *
  43. *  most of these functions.  Rather, it is assumed that the        *
  44. *  68881's OPERR exception will be enabled and handled             *
  45. *  appropriately by the operating system.  Similarly, overflow     *
  46. *  and underflow do not set errno to ERANGE.                       *
  47. *                                                                  *
  48. *  Send bugs to Matthew Self (self@@bayes.arc.nasa.gov).            *
  49. *                                                                  *
  50. *******************************************************************/
  51.  
  52. #ifndef __asm
  53. #define __asm asm               /* until new __asm is done */
  54. #endif
  55.  
  56. #ifndef __inline
  57. #define __inline inline         /* until new __inline is done */
  58. #endif
  59.  
  60. #include <errno.h>
  61.  
  62. #ifndef HUGE_VAL
  63. #define HUGE_VAL                                                        \
  64. ({                                                                      \
  65.   double huge_val;                                                      \
  66.                                                                         \
  67.   __asm ("fmove%.d #0x7ff0000000000000,%0"      /* Infinity */          \
  68.          : "=f" (huge_val)                                              \
  69.          : /* no inputs */);                                            \
  70.   huge_val;                                                             \
  71. })
  72. #endif
  73.  
  74. __inline static const double sin (double x)
  75. {
  76.   double value;
  77.  
  78.   __asm ("fsin%.x %1,%0"
  79.          : "=f" (value)
  80.          : "f" (x));
  81.   return value;
  82. }
  83.  
  84. __inline static const double cos (double x)
  85. { 
  86.   double value;
  87.  
  88.   __asm ("fcos%.x %1,%0"
  89.          : "=f" (value)
  90.          : "f" (x));
  91.   return value;
  92. }
  93.  
  94. __inline static const double tan (double x)
  95. {
  96.   double value;
  97.  
  98.   __asm ("ftan%.x %1,%0"
  99.          : "=f" (value)
  100.          : "f" (x));
  101.   return value;
  102. }
  103.  
  104. __inline static const double asin (double x)
  105. {
  106.   double value;
  107.  
  108.   __asm ("fasin%.x %1,%0"
  109.          : "=f" (value)
  110.          : "f" (x));
  111.   return value;
  112. }
  113.  
  114. __inline static const double acos (double x)
  115. {
  116.   double value;
  117.  
  118.   __asm ("facos%.x %1,%0"
  119.          : "=f" (value)
  120.          : "f" (x));
  121.   return value;
  122. }
  123.  
  124. __inline static const double atan (double x)
  125. {
  126.   double value;
  127.  
  128.   __asm ("fatan%.x %1,%0"
  129.          : "=f" (value)
  130.          : "f" (x));
  131.   return value;
  132. }
  133.  
  134. __inline static const double atan2 (double y, double x)
  135. {
  136.   double pi, pi_over_2;
  137.  
  138.   __asm ("fmovecr%.x %#0,%0"            /* extended precision pi */
  139.          : "=f" (pi)
  140.          : /* no inputs */ );
  141.   __asm ("fscale%.b %#-1,%0"            /* no loss of accuracy */
  142.          : "=f" (pi_over_2)
  143.          : "0" (pi));
  144.   if (x > 0)
  145.     {
  146.       if (y > 0)
  147.         {
  148.           if (x > y)
  149.             return atan (y / x);
  150.           else
  151.             return pi_over_2 - atan (x / y);
  152.         }
  153.       else
  154.         {
  155.           if (x > -y)
  156.             return atan (y / x);
  157.           else
  158.             return - pi_over_2 - atan (x / y);
  159.         }
  160.     }
  161.   else
  162.     {
  163.       if (y > 0)
  164.         {
  165.           if (-x > y)
  166.             return pi + atan (y / x);
  167.           else
  168.             return pi_over_2 - atan (x / y);
  169.         }
  170.       else
  171.         {
  172.           if (-x > -y)
  173.             return - pi + atan (y / x);
  174.           else if (y < 0)
  175.             return - pi_over_2 - atan (x / y);
  176.           else
  177.             {
  178.               double value;
  179.  
  180.               errno = EDOM;
  181.               __asm ("fmove%.d %#0rnan,%0"      /* quiet NaN */
  182.                      : "=f" (value)
  183.                      : /* no inputs */);
  184.               return value;
  185.             }
  186.         }
  187.     }
  188. }
  189.  
  190. __inline static const double sinh (double x)
  191. {
  192.   double value;
  193.  
  194.   __asm ("fsinh%.x %1,%0"
  195.          : "=f" (value)
  196.          : "f" (x));
  197.   return value;
  198. }
  199.  
  200. __inline static const double cosh (double x)
  201. {
  202.   double value;
  203.  
  204.   __asm ("fcosh%.x %1,%0"
  205.          : "=f" (value)
  206.          : "f" (x));
  207.   return value;
  208. }
  209.  
  210. __inline static const double tanh (double x)
  211. {
  212.   double value;
  213.  
  214.   __asm ("ftanh%.x %1,%0"
  215.          : "=f" (value)
  216.          : "f" (x));
  217.   return value;
  218. }
  219.  
  220. __inline static const double exp (double x)
  221. {
  222.   double value;
  223.  
  224.   __asm ("fetox%.x %1,%0"
  225.          : "=f" (value)
  226.          : "f" (x));
  227.   return value;
  228. }
  229.  
  230. __inline static const double log (double x)
  231. {
  232.   double value;
  233.  
  234.   __asm ("flogn%.x %1,%0"
  235.          : "=f" (value)
  236.          : "f" (x));
  237.   return value;
  238. }
  239.  
  240. __inline static const double log10 (double x)
  241. {
  242.   double value;
  243.  
  244.   __asm ("flog10%.x %1,%0"
  245.          : "=f" (value)
  246.          : "f" (x));
  247.   return value;
  248. }
  249.  
  250. __inline static const double pow (const double x, const double y)
  251. {
  252.   if (x > 0)
  253.     return exp (y * log (x));
  254.   else if (x == 0)
  255.     {
  256.       if (y > 0)
  257.         return 0.0;
  258.       else
  259.         {
  260.           double value;
  261.  
  262.           errno = EDOM;
  263.           __asm ("fmove%.d %#0rnan,%0"          /* quiet NaN */
  264.                  : "=f" (value)
  265.                  : /* no inputs */);
  266.           return value;
  267.         }
  268.     }
  269.   else
  270.     {
  271.       double temp;
  272.  
  273.       __asm ("fintrz%.x %1,%0"
  274.              : "=f" (temp)                      /* integer-valued float */
  275.              : "f" (y));
  276.       if (y == temp)
  277.         {
  278.           int i = (int) y;
  279.  
  280.           if (i & 1 == 0)                       /* even */
  281.             return exp (y * log (x));
  282.           else
  283.             return - exp (y * log (x));
  284.         }
  285.       else
  286.         {
  287.           double value;
  288.  
  289.           errno = EDOM;
  290.           __asm ("fmove%.d %#0rnan,%0"          /* quiet NaN */
  291.                  : "=f" (value)
  292.                  : /* no inputs */);
  293.           return value;
  294.         }
  295.     }
  296. }
  297.  
  298. __inline static const double sqrt (double x)
  299. {
  300.   double value;
  301.  
  302.   __asm ("fsqrt%.x %1,%0"
  303.          : "=f" (value)
  304.          : "f" (x));
  305.   return value;
  306. }
  307.  
  308. __inline static const double ceil (double x)
  309. {
  310.   int rounding_mode, round_up;
  311.   double value;
  312.  
  313.   __asm volatile ("fmove%.l fpcr,%0"
  314.                   : "=dm" (rounding_mode)
  315.                   : /* no inputs */ );
  316.   round_up = rounding_mode | 0x30;
  317.   __asm volatile ("fmove%.l %0,fpcr"
  318.                   : /* no outputs */
  319.                   : "dmi" (round_up));
  320.   __asm volatile ("fint%.x %1,%0"
  321.                   : "=f" (value)
  322.                   : "f" (x));
  323.   __asm volatile ("fmove%.l %0,fpcr"
  324.                   : /* no outputs */
  325.                   : "dmi" (rounding_mode));
  326.   return value;
  327. }
  328.  
  329. __inline static const double floor (double x)
  330. {
  331.   int rounding_mode, round_down;
  332.   double value;
  333.  
  334.   __asm volatile ("fmove%.l fpcr,%0"
  335.                   : "=dm" (rounding_mode)
  336.                   : /* no inputs */ );
  337.   round_down = (rounding_mode & ~0x10)
  338.                 | 0x20;
  339.   __asm volatile ("fmove%.l %0,fpcr"
  340.                   : /* no outputs */
  341.                   : "dmi" (round_down));
  342.   __asm volatile ("fint%.x %1,%0"
  343.                   : "=f" (value)
  344.                   : "f" (x));
  345.   __asm volatile ("fmove%.l %0,fpcr"
  346.                   : /* no outputs */
  347.                   : "dmi" (rounding_mode));
  348.   return value;
  349. }
  350.  
  351. #ifndef fabs
  352. __inline static const double fabs (double x)
  353. {
  354.   double value;
  355.  
  356.   __asm ("fabs%.x %1,%0"
  357.          : "=f" (value)
  358.          : "f" (x));
  359.   return value;
  360. }
  361. #endif
  362.  
  363. __inline static const double fmod (double x, double y)
  364. {
  365.   double value;
  366.  
  367.   __asm ("fmod%.x %2,%0"
  368.          : "=f" (value)
  369.          : "0" (x),
  370.            "f" (y));
  371.   return value;
  372. }
  373.  
  374. __inline static const double ldexp (double x, int n)
  375. {
  376.   double value;
  377.  
  378.   __asm ("fscale%.l %2,%0"
  379.          : "=f" (value)
  380.          : "0" (x),
  381.            "dmi" (n));
  382.   return value;
  383. }
  384.  
  385. __inline static double frexp (double x, int *exp)
  386. {
  387.   double float_exponent;
  388.   int int_exponent;
  389.   double mantissa;
  390.  
  391.   __asm ("fgetexp%.x %1,%0"
  392.          : "=f" (float_exponent)        /* integer-valued float */
  393.          : "f" (x));
  394.   int_exponent = (int) float_exponent;
  395.   __asm ("fgetmant%.x %1,%0"
  396.          : "=f" (mantissa)              /* 1.0 <= mantissa < 2.0 */
  397.          : "f" (x));
  398.   if (mantissa != 0)
  399.     {
  400.       __asm ("fscale%.b %#-1,%0"
  401.              : "=f" (mantissa)          /* mantissa /= 2.0 */
  402.              : "0" (mantissa));
  403.       int_exponent += 1;
  404.     }
  405.   *exp = int_exponent;
  406.   return mantissa;
  407. }
  408.  
  409. __inline static double modf (double x, double *ip)
  410.                 /* ip means "integer part" */
  411. {
  412.   __asm ("fintrz%.x %1,%0"
  413.          : "=f" (*ip)        /* integer-valued float */
  414.          : "f" (x));
  415.   return x - (*ip);
  416. }
  417.  
  418.  
  419. @
  420.  
  421.  
  422. 1.1
  423. log
  424. @Initial revision
  425. @
  426. text
  427. @d380 2
  428. a381 1
  429. __inline static double modf (double x, int *ip)
  430. a382 2
  431.   double temp;
  432.  
  433. d384 1
  434. a384 1
  435.          : "=f" (temp)                  /* integer-valued float */
  436. d386 1
  437. a386 2
  438.   *ip = (int) temp;
  439.   return x - temp;
  440. @
  441.